home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / xfs / xfs_log_priv.h < prev    next >
C/C++ Source or Header  |  2005-10-18  |  21KB  |  566 lines
  1. /*
  2.  * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify it
  5.  * under the terms of version 2 of the GNU General Public License as
  6.  * published by the Free Software Foundation.
  7.  *
  8.  * This program is distributed in the hope that it would be useful, but
  9.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11.  *
  12.  * Further, this software is distributed without any warranty that it is
  13.  * free of the rightful claim of any third person regarding infringement
  14.  * or the like.  Any license provided herein, whether implied or
  15.  * otherwise, applies only to this software file.  Patent licenses, if
  16.  * any, provided herein do not apply to combinations of this program with
  17.  * other software, or any other product whatsoever.
  18.  *
  19.  * You should have received a copy of the GNU General Public License along
  20.  * with this program; if not, write the Free Software Foundation, Inc., 59
  21.  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
  22.  *
  23.  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
  24.  * Mountain View, CA  94043, or:
  25.  *
  26.  * http://www.sgi.com
  27.  *
  28.  * For further information regarding this notice, see:
  29.  *
  30.  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
  31.  */
  32. #ifndef    __XFS_LOG_PRIV_H__
  33. #define __XFS_LOG_PRIV_H__
  34.  
  35. struct xfs_buf;
  36. struct ktrace;
  37. struct log;
  38. struct xfs_buf_cancel;
  39. struct xfs_mount;
  40.  
  41. /*
  42.  * Macros, structures, prototypes for internal log manager use.
  43.  */
  44.  
  45. #define XLOG_MIN_ICLOGS        2
  46. #define XLOG_MED_ICLOGS        4
  47. #define XLOG_MAX_ICLOGS        8
  48. #define XLOG_CALLBACK_SIZE    10
  49. #define XLOG_HEADER_MAGIC_NUM    0xFEEDbabe    /* Invalid cycle number */
  50. #define XLOG_VERSION_1        1
  51. #define XLOG_VERSION_2        2        /* Large IClogs, Log sunit */
  52. #define XLOG_VERSION_OKBITS    (XLOG_VERSION_1 | XLOG_VERSION_2)
  53. #define XLOG_RECORD_BSIZE    (16*1024)    /* eventually 32k */
  54. #define XLOG_BIG_RECORD_BSIZE    (32*1024)    /* 32k buffers */
  55. #define XLOG_MAX_RECORD_BSIZE    (256*1024)
  56. #define XLOG_HEADER_CYCLE_SIZE    (32*1024)    /* cycle data in header */
  57. #define XLOG_RECORD_BSHIFT    14        /* 16384 == 1 << 14 */
  58. #define XLOG_BIG_RECORD_BSHIFT    15        /* 32k == 1 << 15 */
  59. #define XLOG_MAX_RECORD_BSHIFT    18        /* 256k == 1 << 18 */
  60. #define XLOG_BTOLSUNIT(log, b)  (((b)+(log)->l_mp->m_sb.sb_logsunit-1) / \
  61.                                  (log)->l_mp->m_sb.sb_logsunit)
  62. #define XLOG_LSUNITTOB(log, su) ((su) * (log)->l_mp->m_sb.sb_logsunit)
  63.  
  64. #define XLOG_HEADER_SIZE    512
  65.  
  66. #define XLOG_REC_SHIFT(log) \
  67.     BTOBB(1 << (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb) ? \
  68.      XLOG_MAX_RECORD_BSHIFT : XLOG_BIG_RECORD_BSHIFT))
  69. #define XLOG_TOTAL_REC_SHIFT(log) \
  70.     BTOBB(XLOG_MAX_ICLOGS << (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb) ? \
  71.      XLOG_MAX_RECORD_BSHIFT : XLOG_BIG_RECORD_BSHIFT))
  72.  
  73. /*
  74.  *  set lsns
  75.  */
  76.  
  77. #define ASSIGN_LSN_CYCLE(lsn,cycle,arch) \
  78.     INT_SET(((uint *)&(lsn))[LSN_FIELD_CYCLE(arch)], arch, (cycle));
  79. #define ASSIGN_LSN_BLOCK(lsn,block,arch) \
  80.     INT_SET(((uint *)&(lsn))[LSN_FIELD_BLOCK(arch)], arch, (block));
  81. #define ASSIGN_ANY_LSN(lsn,cycle,block,arch)  \
  82.     { \
  83.     ASSIGN_LSN_CYCLE(lsn,cycle,arch); \
  84.     ASSIGN_LSN_BLOCK(lsn,block,arch); \
  85.     }
  86. #define ASSIGN_LSN(lsn,log,arch) \
  87.     ASSIGN_ANY_LSN(lsn,(log)->l_curr_cycle,(log)->l_curr_block,arch);
  88.  
  89. #define XLOG_SET(f,b)        (((f) & (b)) == (b))
  90.  
  91. #define GET_CYCLE(ptr, arch) \
  92.     (INT_GET(*(uint *)(ptr), arch) == XLOG_HEADER_MAGIC_NUM ? \
  93.      INT_GET(*((uint *)(ptr)+1), arch) : \
  94.      INT_GET(*(uint *)(ptr), arch) \
  95.     )
  96.  
  97. #define BLK_AVG(blk1, blk2)    ((blk1+blk2) >> 1)
  98.  
  99.  
  100. #ifdef __KERNEL__
  101.  
  102. /*
  103.  * get client id from packed copy.
  104.  *
  105.  * this hack is here because the xlog_pack code copies four bytes
  106.  * of xlog_op_header containing the fields oh_clientid, oh_flags
  107.  * and oh_res2 into the packed copy.
  108.  *
  109.  * later on this four byte chunk is treated as an int and the
  110.  * client id is pulled out.
  111.  *
  112.  * this has endian issues, of course.
  113.  */
  114.  
  115. #if __BYTE_ORDER == __LITTLE_ENDIAN
  116. #define GET_CLIENT_ID(i,arch) \
  117.     ((i) & 0xff)
  118. #else
  119. #define GET_CLIENT_ID(i,arch) \
  120.     ((i) >> 24)
  121. #endif
  122.  
  123. #if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XLOG_GRANT_SUB_SPACE)
  124. void xlog_grant_sub_space(struct log *log, int bytes, int type);
  125. #define XLOG_GRANT_SUB_SPACE(log,bytes,type)    \
  126.     xlog_grant_sub_space(log,bytes,type)
  127. #else
  128. #define XLOG_GRANT_SUB_SPACE(log,bytes,type)                \
  129.     {                                    \
  130.     if (type == 'w') {                        \
  131.         (log)->l_grant_write_bytes -= (bytes);            \
  132.         if ((log)->l_grant_write_bytes < 0) {            \
  133.             (log)->l_grant_write_bytes += (log)->l_logsize;    \
  134.             (log)->l_grant_write_cycle--;            \
  135.         }                            \
  136.     } else {                            \
  137.         (log)->l_grant_reserve_bytes -= (bytes);        \
  138.         if ((log)->l_grant_reserve_bytes < 0) {            \
  139.             (log)->l_grant_reserve_bytes += (log)->l_logsize;\
  140.             (log)->l_grant_reserve_cycle--;            \
  141.         }                            \
  142.      }                                \
  143.     }
  144. #endif
  145. #if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XLOG_GRANT_ADD_SPACE)
  146. void xlog_grant_add_space(struct log *log, int bytes, int type);
  147. #define XLOG_GRANT_ADD_SPACE(log,bytes,type)    \
  148.     xlog_grant_add_space(log,bytes,type)
  149. #else
  150. #define XLOG_GRANT_ADD_SPACE(log,bytes,type)                \
  151.     {                                    \
  152.     if (type == 'w') {                        \
  153.         (log)->l_grant_write_bytes += (bytes);            \
  154.         if ((log)->l_grant_write_bytes > (log)->l_logsize) {    \
  155.             (log)->l_grant_write_bytes -= (log)->l_logsize;    \
  156.             (log)->l_grant_write_cycle++;            \
  157.         }                            \
  158.     } else {                            \
  159.         (log)->l_grant_reserve_bytes += (bytes);        \
  160.         if ((log)->l_grant_reserve_bytes > (log)->l_logsize) {    \
  161.             (log)->l_grant_reserve_bytes -= (log)->l_logsize;\
  162.             (log)->l_grant_reserve_cycle++;            \
  163.         }                            \
  164.      }                                \
  165.     }
  166. #endif
  167. #define XLOG_INS_TICKETQ(q,tic)                \
  168.     {                            \
  169.     if (q) {                    \
  170.         (tic)->t_next        = (q);        \
  171.         (tic)->t_prev        = (q)->t_prev;    \
  172.         (q)->t_prev->t_next = (tic);        \
  173.         (q)->t_prev        = (tic);        \
  174.     } else {                    \
  175.         (tic)->t_prev = (tic)->t_next = (tic);    \
  176.         (q) = (tic);                \
  177.     }                        \
  178.     (tic)->t_flags |= XLOG_TIC_IN_Q;        \
  179.     }
  180. #define XLOG_DEL_TICKETQ(q,tic)                \
  181.     {                            \
  182.     if ((tic) == (tic)->t_next) {            \
  183.         (q) = NULL;                \
  184.     } else {                    \
  185.         (q) = (tic)->t_next;            \
  186.         (tic)->t_next->t_prev = (tic)->t_prev;    \
  187.         (tic)->t_prev->t_next = (tic)->t_next;    \
  188.     }                        \
  189.     (tic)->t_next = (tic)->t_prev = NULL;        \
  190.     (tic)->t_flags &= ~XLOG_TIC_IN_Q;        \
  191.     }
  192.  
  193.  
  194. #define GRANT_LOCK(log)        mutex_spinlock(&(log)->l_grant_lock)
  195. #define GRANT_UNLOCK(log, s)    mutex_spinunlock(&(log)->l_grant_lock, s)
  196. #define LOG_LOCK(log)        mutex_spinlock(&(log)->l_icloglock)
  197. #define LOG_UNLOCK(log, s)    mutex_spinunlock(&(log)->l_icloglock, s)
  198.  
  199. #define xlog_panic(args...)    cmn_err(CE_PANIC, ## args)
  200. #define xlog_exit(args...)    cmn_err(CE_PANIC, ## args)
  201. #define xlog_warn(args...)    cmn_err(CE_WARN, ## args)
  202.  
  203. /*
  204.  * In core log state
  205.  */
  206. #define XLOG_STATE_ACTIVE    0x0001 /* Current IC log being written to */
  207. #define XLOG_STATE_WANT_SYNC 0x0002 /* Want to sync this iclog; no more writes */
  208. #define XLOG_STATE_SYNCING   0x0004 /* This IC log is syncing */
  209. #define XLOG_STATE_DONE_SYNC 0x0008 /* Done syncing to disk */
  210. #define XLOG_STATE_DO_CALLBACK \
  211.                  0x0010 /* Process callback functions */
  212. #define XLOG_STATE_CALLBACK  0x0020 /* Callback functions now */
  213. #define XLOG_STATE_DIRTY     0x0040 /* Dirty IC log, not ready for ACTIVE status*/
  214. #define XLOG_STATE_IOERROR   0x0080 /* IO error happened in sync'ing log */
  215. #define XLOG_STATE_ALL         0x7FFF /* All possible valid flags */
  216. #define XLOG_STATE_NOTUSED   0x8000 /* This IC log not being used */
  217. #endif    /* __KERNEL__ */
  218.  
  219. /*
  220.  * Flags to log operation header
  221.  *
  222.  * The first write of a new transaction will be preceded with a start
  223.  * record, XLOG_START_TRANS.  Once a transaction is committed, a commit
  224.  * record is written, XLOG_COMMIT_TRANS.  If a single region can not fit into
  225.  * the remainder of the current active in-core log, it is split up into
  226.  * multiple regions.  Each partial region will be marked with a
  227.  * XLOG_CONTINUE_TRANS until the last one, which gets marked with XLOG_END_TRANS.
  228.  *
  229.  */
  230. #define XLOG_START_TRANS    0x01    /* Start a new transaction */
  231. #define XLOG_COMMIT_TRANS    0x02    /* Commit this transaction */
  232. #define XLOG_CONTINUE_TRANS    0x04    /* Cont this trans into new region */
  233. #define XLOG_WAS_CONT_TRANS    0x08    /* Cont this trans into new region */
  234. #define XLOG_END_TRANS        0x10    /* End a continued transaction */
  235. #define XLOG_UNMOUNT_TRANS    0x20    /* Unmount a filesystem transaction */
  236. #define XLOG_SKIP_TRANS        (XLOG_COMMIT_TRANS | XLOG_CONTINUE_TRANS | \
  237.                  XLOG_WAS_CONT_TRANS | XLOG_END_TRANS | \
  238.                  XLOG_UNMOUNT_TRANS)
  239.  
  240. #ifdef __KERNEL__
  241. /*
  242.  * Flags to log ticket
  243.  */
  244. #define XLOG_TIC_INITED        0x1    /* has been initialized */
  245. #define XLOG_TIC_PERM_RESERV    0x2    /* permanent reservation */
  246. #define XLOG_TIC_IN_Q        0x4
  247. #endif    /* __KERNEL__ */
  248.  
  249. #define XLOG_UNMOUNT_TYPE    0x556e    /* Un for Unmount */
  250.  
  251. /*
  252.  * Flags for log structure
  253.  */
  254. #define XLOG_CHKSUM_MISMATCH    0x1    /* used only during recovery */
  255. #define XLOG_ACTIVE_RECOVERY    0x2    /* in the middle of recovery */
  256. #define    XLOG_RECOVERY_NEEDED    0x4    /* log was recovered */
  257. #define XLOG_IO_ERROR        0x8    /* log hit an I/O error, and being
  258.                        shutdown */
  259. typedef __uint32_t xlog_tid_t;
  260.  
  261.  
  262. #ifdef __KERNEL__
  263. /*
  264.  * Below are states for covering allocation transactions.
  265.  * By covering, we mean changing the h_tail_lsn in the last on-disk
  266.  * log write such that no allocation transactions will be re-done during
  267.  * recovery after a system crash. Recovery starts at the last on-disk
  268.  * log write.
  269.  *
  270.  * These states are used to insert dummy log entries to cover
  271.  * space allocation transactions which can undo non-transactional changes
  272.  * after a crash. Writes to a file with space
  273.  * already allocated do not result in any transactions. Allocations
  274.  * might include space beyond the EOF. So if we just push the EOF a
  275.  * little, the last transaction for the file could contain the wrong
  276.  * size. If there is no file system activity, after an allocation
  277.  * transaction, and the system crashes, the allocation transaction
  278.  * will get replayed and the file will be truncated. This could
  279.  * be hours/days/... after the allocation occurred.
  280.  *
  281.  * The fix for this is to do two dummy transactions when the
  282.  * system is idle. We need two dummy transaction because the h_tail_lsn
  283.  * in the log record header needs to point beyond the last possible
  284.  * non-dummy transaction. The first dummy changes the h_tail_lsn to
  285.  * the first transaction before the dummy. The second dummy causes
  286.  * h_tail_lsn to point to the first dummy. Recovery starts at h_tail_lsn.
  287.  *
  288.  * These dummy transactions get committed when everything
  289.  * is idle (after there has been some activity).
  290.  *
  291.  * There are 5 states used to control this.
  292.  *
  293.  *  IDLE -- no logging has been done on the file system or
  294.  *        we are done covering previous transactions.
  295.  *  NEED -- logging has occurred and we need a dummy transaction
  296.  *        when the log becomes idle.
  297.  *  DONE -- we were in the NEED state and have committed a dummy
  298.  *        transaction.
  299.  *  NEED2 -- we detected that a dummy transaction has gone to the
  300.  *        on disk log with no other transactions.
  301.  *  DONE2 -- we committed a dummy transaction when in the NEED2 state.
  302.  *
  303.  * There are two places where we switch states:
  304.  *
  305.  * 1.) In xfs_sync, when we detect an idle log and are in NEED or NEED2.
  306.  *    We commit the dummy transaction and switch to DONE or DONE2,
  307.  *    respectively. In all other states, we don't do anything.
  308.  *
  309.  * 2.) When we finish writing the on-disk log (xlog_state_clean_log).
  310.  *
  311.  *    No matter what state we are in, if this isn't the dummy
  312.  *    transaction going out, the next state is NEED.
  313.  *    So, if we aren't in the DONE or DONE2 states, the next state
  314.  *    is NEED. We can't be finishing a write of the dummy record
  315.  *    unless it was committed and the state switched to DONE or DONE2.
  316.  *
  317.  *    If we are in the DONE state and this was a write of the
  318.  *        dummy transaction, we move to NEED2.
  319.  *
  320.  *    If we are in the DONE2 state and this was a write of the
  321.  *        dummy transaction, we move to IDLE.
  322.  *
  323.  *
  324.  * Writing only one dummy transaction can get appended to
  325.  * one file space allocation. When this happens, the log recovery
  326.  * code replays the space allocation and a file could be truncated.
  327.  * This is why we have the NEED2 and DONE2 states before going idle.
  328.  */
  329.  
  330. #define XLOG_STATE_COVER_IDLE    0
  331. #define XLOG_STATE_COVER_NEED    1
  332. #define XLOG_STATE_COVER_DONE    2
  333. #define XLOG_STATE_COVER_NEED2    3
  334. #define XLOG_STATE_COVER_DONE2    4
  335.  
  336. #define XLOG_COVER_OPS        5
  337.  
  338. typedef struct xlog_ticket {
  339.     sv_t           t_sema;     /* sleep on this semaphore     :20 */
  340.     struct xlog_ticket *t_next;     /*                     : 4 */
  341.     struct xlog_ticket *t_prev;     /*                 : 4 */
  342.     xlog_tid_t       t_tid;     /* transaction identifier     : 4 */
  343.     int           t_curr_res;     /* current reservation in bytes : 4 */
  344.     int           t_unit_res;     /* unit reservation in bytes    : 4 */
  345.     __uint8_t       t_ocnt;     /* original count         : 1 */
  346.     __uint8_t       t_cnt;     /* current count         : 1 */
  347.     __uint8_t       t_clientid;     /* who does this belong to;     : 1 */
  348.     __uint8_t       t_flags;     /* properties of reservation     : 1 */
  349. } xlog_ticket_t;
  350. #endif
  351.  
  352.  
  353. typedef struct xlog_op_header {
  354.     xlog_tid_t oh_tid;    /* transaction id of operation    :  4 b */
  355.     int       oh_len;    /* bytes in data region        :  4 b */
  356.     __uint8_t  oh_clientid;    /* who sent me this        :  1 b */
  357.     __uint8_t  oh_flags;    /*                :  1 b */
  358.     ushort       oh_res2;    /* 32 bit align            :  2 b */
  359. } xlog_op_header_t;
  360.  
  361.  
  362. /* valid values for h_fmt */
  363. #define XLOG_FMT_UNKNOWN  0
  364. #define XLOG_FMT_LINUX_LE 1
  365. #define XLOG_FMT_LINUX_BE 2
  366. #define XLOG_FMT_IRIX_BE  3
  367.  
  368. /* our fmt */
  369. #if __BYTE_ORDER == __LITTLE_ENDIAN
  370. #define XLOG_FMT XLOG_FMT_LINUX_LE
  371. #else
  372. #if __BYTE_ORDER == __BIG_ENDIAN
  373. #define XLOG_FMT XLOG_FMT_LINUX_BE
  374. #else
  375. #error unknown byte order
  376. #endif
  377. #endif
  378.  
  379. typedef struct xlog_rec_header {
  380.     uint      h_magicno;    /* log record (LR) identifier        :  4 */
  381.     uint      h_cycle;    /* write cycle of log            :  4 */
  382.     int      h_version;    /* LR version                :  4 */
  383.     int      h_len;    /* len in bytes; should be 64-bit aligned: 4 */
  384.     xfs_lsn_t h_lsn;    /* lsn of this LR            :  8 */
  385.     xfs_lsn_t h_tail_lsn;    /* lsn of 1st LR w/ buffers not committed: 8 */
  386.     uint      h_chksum;    /* may not be used; non-zero if used    :  4 */
  387.     int      h_prev_block; /* block number to previous LR        :  4 */
  388.     int      h_num_logops;    /* number of log operations in this LR    :  4 */
  389.     uint      h_cycle_data[XLOG_HEADER_CYCLE_SIZE / BBSIZE];
  390.     /* new fields */
  391.     int       h_fmt;        /* format of log record                 :  4 */
  392.     uuid_t    h_fs_uuid;    /* uuid of FS                           : 16 */
  393.     int       h_size;    /* iclog size                :  4 */
  394. } xlog_rec_header_t;
  395.  
  396. typedef struct xlog_rec_ext_header {
  397.     uint      xh_cycle;    /* write cycle of log            : 4 */
  398.     uint      xh_cycle_data[XLOG_HEADER_CYCLE_SIZE / BBSIZE]; /*    : 256 */
  399. } xlog_rec_ext_header_t;
  400.  
  401. #ifdef __KERNEL__
  402. /*
  403.  * - A log record header is 512 bytes.  There is plenty of room to grow the
  404.  *    xlog_rec_header_t into the reserved space.
  405.  * - ic_data follows, so a write to disk can start at the beginning of
  406.  *    the iclog.
  407.  * - ic_forcesema is used to implement synchronous forcing of the iclog to disk.
  408.  * - ic_next is the pointer to the next iclog in the ring.
  409.  * - ic_bp is a pointer to the buffer used to write this incore log to disk.
  410.  * - ic_log is a pointer back to the global log structure.
  411.  * - ic_callback is a linked list of callback function/argument pairs to be
  412.  *    called after an iclog finishes writing.
  413.  * - ic_size is the full size of the header plus data.
  414.  * - ic_offset is the current number of bytes written to in this iclog.
  415.  * - ic_refcnt is bumped when someone is writing to the log.
  416.  * - ic_state is the state of the iclog.
  417.  */
  418. typedef struct xlog_iclog_fields {
  419.     sv_t            ic_forcesema;
  420.     sv_t            ic_writesema;
  421.     struct xlog_in_core    *ic_next;
  422.     struct xlog_in_core    *ic_prev;
  423.     struct xfs_buf        *ic_bp;
  424.     struct log        *ic_log;
  425.     xfs_log_callback_t    *ic_callback;
  426.     xfs_log_callback_t    **ic_callback_tail;
  427. #ifdef XFS_LOG_TRACE
  428.     struct ktrace        *ic_trace;
  429. #endif
  430.     int            ic_size;
  431.     int            ic_offset;
  432.     int            ic_refcnt;
  433.     int            ic_roundoff;
  434.     int            ic_bwritecnt;
  435.     ushort_t        ic_state;
  436.     char            *ic_datap;    /* pointer to iclog data */
  437. } xlog_iclog_fields_t;
  438.  
  439. typedef union xlog_in_core2 {
  440.     xlog_rec_header_t    hic_header;
  441.     xlog_rec_ext_header_t    hic_xheader;
  442.     char            hic_sector[XLOG_HEADER_SIZE];
  443. } xlog_in_core_2_t;
  444.  
  445. typedef struct xlog_in_core {
  446.     xlog_iclog_fields_t    hic_fields;
  447.     xlog_in_core_2_t    *hic_data;
  448. } xlog_in_core_t;
  449.  
  450. /*
  451.  * Defines to save our code from this glop.
  452.  */
  453. #define    ic_forcesema    hic_fields.ic_forcesema
  454. #define ic_writesema    hic_fields.ic_writesema
  455. #define    ic_next        hic_fields.ic_next
  456. #define    ic_prev        hic_fields.ic_prev
  457. #define    ic_bp        hic_fields.ic_bp
  458. #define    ic_log        hic_fields.ic_log
  459. #define    ic_callback    hic_fields.ic_callback
  460. #define    ic_callback_tail hic_fields.ic_callback_tail
  461. #define    ic_trace    hic_fields.ic_trace
  462. #define    ic_size        hic_fields.ic_size
  463. #define    ic_offset    hic_fields.ic_offset
  464. #define    ic_refcnt    hic_fields.ic_refcnt
  465. #define    ic_roundoff    hic_fields.ic_roundoff
  466. #define    ic_bwritecnt    hic_fields.ic_bwritecnt
  467. #define    ic_state    hic_fields.ic_state
  468. #define ic_datap    hic_fields.ic_datap
  469. #define ic_header    hic_data->hic_header
  470.  
  471. /*
  472.  * The reservation head lsn is not made up of a cycle number and block number.
  473.  * Instead, it uses a cycle number and byte number.  Logs don't expect to
  474.  * overflow 31 bits worth of byte offset, so using a byte number will mean
  475.  * that round off problems won't occur when releasing partial reservations.
  476.  */
  477. typedef struct log {
  478.     /* The following block of fields are changed while holding icloglock */
  479.     sema_t            l_flushsema;    /* iclog flushing semaphore */
  480.     int            l_flushcnt;    /* # of procs waiting on this
  481.                          * sema */
  482.     int            l_ticket_cnt;    /* free ticket count */
  483.     int            l_ticket_tcnt;    /* total ticket count */
  484.     int            l_covered_state;/* state of "covering disk
  485.                          * log entries" */
  486.     xlog_ticket_t        *l_freelist;    /* free list of tickets */
  487.     xlog_ticket_t        *l_unmount_free;/* kmem_free these addresses */
  488.     xlog_ticket_t        *l_tail;        /* free list of tickets */
  489.     xlog_in_core_t        *l_iclog;       /* head log queue    */
  490.     lock_t            l_icloglock;    /* grab to change iclog state */
  491.     xfs_lsn_t        l_tail_lsn;     /* lsn of 1st LR with unflushed
  492.                          * buffers */
  493.     xfs_lsn_t        l_last_sync_lsn;/* lsn of last LR on disk */
  494.     struct xfs_mount    *l_mp;            /* mount point */
  495.     struct xfs_buf        *l_xbuf;        /* extra buffer for log
  496.                          * wrapping */
  497.     struct xfs_buftarg    *l_targ;        /* buftarg of log */
  498.     xfs_daddr_t        l_logBBstart;   /* start block of log */
  499.     int            l_logsize;      /* size of log in bytes */
  500.     int            l_logBBsize;    /* size of log in BB chunks */
  501.     int            l_roundoff;    /* round off error of iclogs */
  502.     int            l_curr_cycle;   /* Cycle number of log writes */
  503.     int            l_prev_cycle;   /* Cycle number before last
  504.                          * block increment */
  505.     int            l_curr_block;   /* current logical log block */
  506.     int            l_prev_block;   /* previous logical log block */
  507.     int            l_iclog_size;    /* size of log in bytes */
  508.     int            l_iclog_size_log; /* log power size of log */
  509.     int            l_iclog_bufs;    /* number of iclog buffers */
  510.  
  511.     /* The following field are used for debugging; need to hold icloglock */
  512.     char            *l_iclog_bak[XLOG_MAX_ICLOGS];
  513.  
  514.     /* The following block of fields are changed while holding grant_lock */
  515.     lock_t            l_grant_lock;
  516.     xlog_ticket_t        *l_reserve_headq;
  517.     xlog_ticket_t        *l_write_headq;
  518.     int            l_grant_reserve_cycle;
  519.     int            l_grant_reserve_bytes;
  520.     int            l_grant_write_cycle;
  521.     int            l_grant_write_bytes;
  522.  
  523.     /* The following fields don't need locking */
  524. #ifdef XFS_LOG_TRACE
  525.     struct ktrace        *l_trace;
  526.     struct ktrace        *l_grant_trace;
  527. #endif
  528.     uint            l_flags;
  529.     uint            l_quotaoffs_flag; /* XFS_DQ_*, for QUOTAOFFs */
  530.     struct xfs_buf_cancel    **l_buf_cancel_table;
  531.     int            l_iclog_hsize;  /* size of iclog header */
  532.     int            l_iclog_heads;  /* # of iclog header sectors */
  533.     uint            l_sectbb_log;   /* log2 of sector size in BBs */
  534.     uint            l_sectbb_mask;  /* sector size (in BBs)
  535.                          * alignment mask */
  536. } xlog_t;
  537.  
  538.  
  539. /* common routines */
  540. extern xfs_lsn_t xlog_assign_tail_lsn(struct xfs_mount *mp);
  541. extern int     xlog_find_head(xlog_t *log, xfs_daddr_t *head_blk);
  542. extern int     xlog_find_tail(xlog_t    *log,
  543.                 xfs_daddr_t *head_blk,
  544.                 xfs_daddr_t *tail_blk,
  545.                 int readonly);
  546. extern int     xlog_print_find_oldest(xlog_t *log, xfs_daddr_t *last_blk);
  547. extern int     xlog_recover(xlog_t *log, int readonly);
  548. extern int     xlog_recover_finish(xlog_t *log, int mfsi_flags);
  549. extern void     xlog_pack_data(xlog_t *log, xlog_in_core_t *iclog);
  550. extern void     xlog_recover_process_iunlinks(xlog_t *log);
  551.  
  552. extern struct xfs_buf *xlog_get_bp(xlog_t *, int);
  553. extern void     xlog_put_bp(struct xfs_buf *);
  554. extern int     xlog_bread(xlog_t *, xfs_daddr_t, int, struct xfs_buf *);
  555. extern xfs_caddr_t xlog_align(xlog_t *, xfs_daddr_t, int, struct xfs_buf *);
  556.  
  557. /* iclog tracing */
  558. #define XLOG_TRACE_GRAB_FLUSH  1
  559. #define XLOG_TRACE_REL_FLUSH   2
  560. #define XLOG_TRACE_SLEEP_FLUSH 3
  561. #define XLOG_TRACE_WAKE_FLUSH  4
  562.  
  563. #endif    /* __KERNEL__ */
  564.  
  565. #endif    /* __XFS_LOG_PRIV_H__ */
  566.